package cn.bluethink.eguan.model.core;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.springframework.stereotype.Component;

/**
 * @title 驿馆+产品中的江湖对象，全局唯一
 * @Copyright 苏州中科蓝迪公司所有(c)2016-2021
 * @version 0.1
 *
 * @note 修订历史： （1）giszyj@126.com于2018年10月06日设计并构建初始版本v1.0.0
 */
@Component
public class EgConfigInfo {

    /**
     * 系统账户 注意：只有在需要时，才会获取账户的余额
     */
    private final Long acountId = 6074052763648L;

    /**
     * 系统中对象类型缓存，系统启动时优先加载
     */
    private Map<Integer, EgOType> otypes = new HashMap<Integer, EgOType>();

    /**
     * 系统动作类型缓存，系统启动时在对象类型加载完后加载
     */
    private Map<Integer, EgActionType> actiontypes = new HashMap<Integer, EgActionType>();

    /**
     * 对象类型所具有动作类型缓存，系统启动时在动作类型加载完后加载
     */
    private Map<Integer, Map<Integer, EgOtAction>> otactions = new HashMap<Integer, Map<Integer, EgOtAction>>();

    /**
     * 系统权限缓存，系统启动时加载
     */
    private Map<Integer, EgPurview> purviews = new HashMap<Integer, EgPurview>();

    /**
     * 系统角色缓存，系统启动时加载
     */
    private Map<Integer, EgRole> roles = new HashMap<Integer, EgRole>();
    /**
     * 系统角色在不同域中所对应角色和权限缓存，系统启动时加载
     */
    private Map<Integer, Map<Integer, EgRole>> rpurviews = new HashMap<Integer, Map<Integer, EgRole>>();

    /**
     * 江湖
     */
    private EgObject jianghu = new EgObject(0L, "驿馆江湖", new EgOType(EgOType.JIANGHU, null));

    /**
     * @roseuid 5BB030BE03B9
     */
    public EgConfigInfo() {

    }

    /**
     * 获取系统账户Id
     * 
     * @return EgAcount
     */
    public Long getAcountId() {
        return acountId;
    }

    /**
     * 增加对象类型缓存
     * 
     * @param otype对象类型
     * @param t_name类型主表名
     */
    synchronized public void addOType(Integer id, String o_name) {
        EgOType otype = new EgOType(id, o_name);
        otypes.put(otype.getOtid(), otype);
    }

    /**
     * 获取驿馆产品内置支持的对象类型
     * 
     * @return
     */
    public Map<Integer, EgOType> otypes() {
        return otypes;
    }

    /**
     * 增加动作类型缓存
     * 
     * @param atid
     *            动作类型唯一标识
     * @param name
     *            动作类型名称
     */
    synchronized public void addActionType(Integer atid, String name) {
        EgActionType at = new EgActionType(atid, name);
        actiontypes.put(at.getAtid(), at);
    }

    /**
     * 返回系统支持的动作类型
     * 
     * @return
     */
    public Map<Integer, EgActionType> actionTypes() {
        return actiontypes;
    }

    /**
     * 增加某一对象类型多对应的动作类型缓存
     * 
     * @param otype
     *            所针对的对象类型标识
     * @param atid
     *            该对象类型所支持的动作类型标识
     * @param rtype
     *            该动作类型的结果对象类型
     */
    synchronized public void addOTAction(Integer otype, Integer atid, Integer rtype, Integer flag) {
        Map<Integer, EgOtAction> otats = otactions.get(otype);
        if (otats == null) {
            otats = new HashMap<Integer, EgOtAction>();
            otactions.put(otype, otats);
        }
        EgActionType at = actiontypes.get(atid);
        if (at != null)
            otats.put(at.getAtid(), new EgOtAction(at, otypes.get(rtype), flag));
    }

    /**
     * 获取某一对象类型所支持的动作类型
     * 
     * @param otype
     * @return （动作类型标识-EgOtAction对象）键值对列表
     */
    public Map<Integer, EgOtAction> actionTypes(Integer otype) {
        return otactions.get(otype);
    }

    /**
     * 增加权限缓存
     * 
     * @param purview
     */
    synchronized public void addPurview(int id, String name, String des) {
        EgPurview purview = new EgPurview(id, name, des);
        purviews.put(purview.getId(), purview);
    }

    /**
     * 获取系统所支持的权限
     * 
     * @return
     */
    public Map<Integer, EgPurview> purviews() {
        return purviews;
    }

    /**
     * 根据用户权限值获取详细权限列表
     * 
     * @param purview
     * @return
     */
    public List<EgPurview> purviews(Integer purview) {
        List<EgPurview> result = new ArrayList<EgPurview>();
        for (Map.Entry<Integer, EgPurview> et : purviews.entrySet()) {
            if ((purview & et.getKey()) != 0)
                result.add(et.getValue());
        }
        return result;
    }

    /**
     * 增加系统默认角色权限信息
     * 
     * @param rid
     * @param name
     * @param role4
     * @param purview4
     * @param role2
     * @param purview2
     * @param role1
     * @param purview1
     */
    synchronized public void addRole(int rid, String name, int role4, int purview4, int role2, int purview2, int role1,
            int purview1) {
        EgRole role = new EgRole(rid, name, null);
        roles.put(role.getRid(), role);
        HashMap<Integer, EgRole> rs = new HashMap<Integer, EgRole>();
        rs.put(EgScope.WULIN, new EgRole(role4, null, purview4));
        rs.put(EgScope.FACTION, new EgRole(role2, null, purview2));
        rs.put(EgScope.TAVERN, new EgRole(role1, null, purview1));
        rpurviews.put(rid, rs);
    }

    /**
     * 获取系统支持的角色
     * 
     * @return
     */
    public Map<Integer, EgRole> roles() {
        return roles;
    }

    /**
     * 根据角色值和所处的域，获取适合的角色名字
     * 
     * @param role
     * @param scope
     */
    public String roleName(int role, int scope) {
        String name = "访客";
        switch (scope) {
        case EgScope.TAVERN: {
            if ((role & EgRole.SHOPKEEPER) != 0)
                name = roles.get(EgRole.SHOPKEEPER).getName();
            else if ((role & EgRole.STAFF) != 0)
                name = roles.get(EgRole.STAFF).getName();
        }
            break;
        case EgScope.FACTION: {
            if ((role & EgRole.CHEAF) != 0)
                name = roles.get(EgRole.CHEAF).getName();
            else if ((role & EgRole.VICE_CHEAF) != 0)
                name = roles.get(EgRole.VICE_CHEAF).getName();
            else if ((role & EgRole.MEMBER) != 0)
                name = roles.get(EgRole.MEMBER).getName();
        }
            break;
        case EgScope.WULIN: {
            if ((role & EgRole.SUPERMANAGER) != 0)
                name = roles.get(EgRole.SUPERMANAGER).getName();
            else if ((role & EgRole.MANAGER) != 0)
                name = roles.get(EgRole.MANAGER).getName();
            else
                name = roles.get(EgRole.TRAVELER).getName();
        }
            break;
        default:
            break;
        }
        return name;
    }

    /**
     * 根据角色唯一标识，获取范围域中的默认角色值和权限
     * 
     * @param rid
     * @return 返回值以范围域为key进行索引
     */
    public Map<Integer, EgRole> role(int rid) {
        return rpurviews.get(rid);
    }

    /**
     * 获取江湖对象
     */
    public EgObject jianghu() {
        return jianghu;
    }
}
